package com.atguigu.gmall.activity.service.impl;

import com.atguigu.gmall.activity.mapper.CouponInfoMapper;
import com.atguigu.gmall.activity.mapper.CouponRangeMapper;
import com.atguigu.gmall.activity.mapper.CouponUseMapper;
import com.atguigu.gmall.activity.service.CouponInfoService;
import com.atguigu.gmall.model.activity.*;
import com.atguigu.gmall.model.cart.CartInfo;
import com.atguigu.gmall.model.enums.CouponRangeType;
import com.atguigu.gmall.model.enums.CouponStatus;
import com.atguigu.gmall.model.enums.CouponType;
import com.atguigu.gmall.model.order.OrderDetail;
import com.atguigu.gmall.model.product.BaseCategory3;
import com.atguigu.gmall.model.product.BaseTrademark;
import com.atguigu.gmall.model.product.SkuInfo;
import com.atguigu.gmall.model.product.SpuInfo;
import com.atguigu.gmall.product.client.ProductFeignClient;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author atguigu-mqx
 */
@Service
public class CouponInfoServiceImpl extends ServiceImpl<CouponInfoMapper,CouponInfo> implements CouponInfoService {

    //  调用mapper 层
    @Autowired
    private CouponInfoMapper couponInfoMapper;

    @Autowired
    private CouponRangeMapper couponRangeMapper;

    @Autowired
    private CouponUseMapper couponUseMapper;

    @Autowired
    private ProductFeignClient productFeignClient;

    @Override
    public IPage<CouponInfo> getPage(Page<CouponInfo> pageParam) {
        //  查询的时候按照Id 就行降序排列
        QueryWrapper<CouponInfo> couponInfoQueryWrapper = new QueryWrapper<>();
        couponInfoQueryWrapper.orderByDesc("id");
        Page<CouponInfo> couponInfoPage = couponInfoMapper.selectPage(pageParam, couponInfoQueryWrapper);

        //  细节处理：
        couponInfoPage.getRecords().stream().forEach(couponInfo -> {
            //  赋值优惠券类型数据
            couponInfo.setCouponTypeString(CouponType.getNameByType(couponInfo.getCouponType()));

            //  赋值优惠券的使用范围 rangeTypeString
            if (couponInfo.getRangeType()!=null){
                couponInfo.setRangeTypeString(CouponRangeType.getNameByType(couponInfo.getRangeType()));
            }

        });
        //  返回数据
        return couponInfoPage;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveCouponRule(CouponRuleVo couponRuleVo) {
        //  完成实现！ coupon_range --- insert ，coupon_info -- update！
        //  先删除原有优惠券范围列表数据！
        QueryWrapper<CouponRange> couponRangeQueryWrapper = new QueryWrapper<>();
        couponRangeQueryWrapper.eq("coupon_id",couponRuleVo.getCouponId());
        //  删除数据
        couponRangeMapper.delete(couponRangeQueryWrapper);

        //  优惠券主表做更新：
        CouponInfo couponInfo = this.getById(couponRuleVo.getCouponId());
        //  做赋值操作：
        couponInfo.setRangeType(couponRuleVo.getRangeType().name());
        couponInfo.setConditionAmount(couponRuleVo.getConditionAmount());
        couponInfo.setConditionNum(couponRuleVo.getConditionNum());
        couponInfo.setBenefitAmount(couponRuleVo.getBenefitAmount());
        couponInfo.setBenefitDiscount(couponRuleVo.getBenefitDiscount());
        couponInfo.setRangeDesc(couponRuleVo.getRangeDesc());

        // 更新操作
        this.updateById(couponInfo);

        //  先获取到优惠券范围列表集合
        List<CouponRange> couponRangeList = couponRuleVo.getCouponRangeList();
        if (!CollectionUtils.isEmpty(couponRangeList)){
            //  循环遍历
            for (CouponRange couponRange : couponRangeList) {
                //  将优惠券Id 存储
                couponRange.setCouponId(couponRuleVo.getCouponId());
                //  新增数据
                couponRangeMapper.insert(couponRange);
            }
        }

    }

    @Override
    public Map<String, Object> findCouponRuleList(Long id) {
        //  声明一个map 集合对象
        Map<String, Object> map = new HashMap<>();
        //  根据优惠券Id 获取到当前对象
        CouponInfo couponInfo = this.getById(id);
        //  coupon_range 获取到对应的 range_id 可能是spuId ,也有可能是tmId ,也有可能是三级分类Id
        QueryWrapper<CouponRange> couponRangeQueryWrapper = new QueryWrapper<>();
        couponRangeQueryWrapper.eq("coupon_id",id);
        //  根据优惠券Id 获取到优惠券的使用范围集合
        List<CouponRange> couponRangeList = couponRangeMapper.selectList(couponRangeQueryWrapper);

        //  获取到range_Id
        List<Long> rangeIdList = couponRangeList.stream().map(CouponRange::getRangeId).collect(Collectors.toList());
        //  判断当前集合不为空！
        if (!CollectionUtils.isEmpty(rangeIdList)){
            //  判断rangeId是属于哪一种类型！
            if (couponInfo.getRangeType().equals(CouponRangeType.SPU.name())){
                //  对应的range_Id 是 spuId 远程调用方法
                List<SpuInfo> spuInfoList = productFeignClient.findSpuInfoBySpuIdList(rangeIdList);
                //  保存数据：这个key 是页面固定写好的spuInfoList
                map.put("spuInfoList",spuInfoList);
            }else  if (couponInfo.getRangeType().equals(CouponRangeType.CATAGORY.name())){
                //  对应的range_Id 是 category3Id 远程调用方法
                List<BaseCategory3> category3List = productFeignClient.findBaseCategory3ByCategory3IdList(rangeIdList);
                //  数据保存：
                map.put("category3List",category3List);
            }else {
                //  对应的range_Id 是 tmId 远程调用方法
                List<BaseTrademark> baseTrademarkList = productFeignClient.findBaseTrademarkByTrademarkIdList(rangeIdList);
                //  存储数据：
                map.put("trademarkList",baseTrademarkList);
            }
        }
        //  返回map
        return map;
    }

    @Override
    public List<CouponInfo> findCouponByKeyword(String keyword) {
        //  根据优惠券的名称进行模糊查询！
        QueryWrapper<CouponInfo> couponInfoQueryWrapper = new QueryWrapper<>();
        couponInfoQueryWrapper.like("coupon_name",keyword);
        //  获取到集合数据
        List<CouponInfo> couponInfoList = couponInfoMapper.selectList(couponInfoQueryWrapper);
        return couponInfoList;
    }

    @Override
    public List<CouponInfo> findCouponInfo(Long skuId, Long userId) {
        //  skuId 是通过商品详情页面直接传递过来的 ，因为：需要通过skuId 获取到skuInfo！
        //  skuInfo 中有 品牌Id，三级分类Id，spuId!  优惠券的使用范围：品牌，三级分类Id，spu ,
        //  商品详情页面 ：skuId = 42
        //  userId 通过控制器获取到！ 查询是否领用
        //  根据skuId 获取到skuInfo 对象
        SkuInfo skuInfo = productFeignClient.getSkuInfo(skuId);
        //  判断skuInfo 不为空！
        if (skuInfo == null) return new ArrayList<>();
        //  获取到优惠券列表！
        List<CouponInfo> couponInfoList = couponInfoMapper.selectCouponInfoList(skuInfo.getSpuId(),skuInfo.getCategory3Id(),skuInfo.getTmId(),userId);
        //  返回优惠券列表
        return couponInfoList;
    }

    @Override
    public IPage<CouponInfo> getPageByUserId(Page<CouponInfo> couponInfoPage, Long userId) {
        //        QueryWrapper<CouponInfo> couponInfoQueryWrapper = new QueryWrapper<>();
        //        couponInfoQueryWrapper.eq("user_id",userId);
        //        couponInfoMapper.selectPage(couponInfoPage,couponInfoQueryWrapper);

        //  在此，应该查询coupon_info,coupon_use
        IPage<CouponInfo> page =  couponInfoMapper.selectPageByUserId(couponInfoPage,userId);
        //  返回数据
        return page;
    }

    @Override
    public Map<Long, List<CouponInfo>> findCartCouponInfo(List<CartInfo> cartInfoList, Map<Long, Long> skuIdToActivityIdMap, Long userId) {

        //  定义一个集合
        Map<Long,SkuInfo> skuIdToSkuInfoMap = new HashMap<>();

        //  定义一个集合
        Map<String,List<Long>> rangToSkuIdMap = new HashMap<>();

        //  skuInfoList 获取到skuInfoList 集合
        ArrayList<SkuInfo> skuInfoList = new ArrayList<>();
        //  循环遍历cartInfoList
        for (CartInfo cartInfo : cartInfoList) {
            SkuInfo skuInfo = productFeignClient.getSkuInfo(cartInfo.getSkuId());
            //  将skuInfo 添加到集合
            skuInfoList.add(skuInfo);
            skuIdToSkuInfoMap.put(cartInfo.getSkuId(),skuInfo);
            //  初始化操作：
            this.setRuleData(skuInfo,rangToSkuIdMap);
        }

        //  先获取到所有的优惠券数据
        List<CouponInfo> allCouponInfoList = couponInfoMapper.selectCartCouponInfoList(skuInfoList,userId);
        //  做一个循环遍历获取数据！
        for (CouponInfo couponInfo : allCouponInfoList) {
            //  获取到优惠券对应订单使用范围Id  category3Id spuId tmId;
            Long rangeId = couponInfo.getRangeId();

            //  获取到使用范围
            String rangeType = couponInfo.getRangeType();


            //  优惠券： 普通优惠券，活动优惠券{这个优惠券参与活动}
            if (couponInfo.getActivityId()!=null && couponInfo.getActivityId().intValue()!=0){
                //  声明一个skuIdList 集合
                List<Long> skuIdList = new ArrayList<>();
                //  找到活动下的skuIdList ;
                Iterator<Map.Entry<Long, Long>> iterator = skuIdToActivityIdMap.entrySet().iterator();
                while (iterator.hasNext()){
                    Map.Entry<Long, Long> entry = iterator.next();
                    //  获取的skuId
                    Long skuId = entry.getKey();
                    Long activityId = entry.getValue();
                    //  ------------------------ skuIdToActivityIdMap 由来！
                    //  找到了对应活动优惠券
                    if (activityId.longValue()==couponInfo.getActivityId().longValue()){
                        //  获取skuInfo
                        SkuInfo skuInfo = skuIdToSkuInfoMap.get(skuId);
                        //  优惠券的使用范围： spu , category3Id,tmId
                        if (rangeType.equals(CouponRangeType.SPU.name())){
                            //  属于spu 使用范围，并且将对应的skuId 保存到集合中！
                            if (skuInfo.getSpuId().longValue()==rangeId.longValue()){
                                skuIdList.add(skuId);
                            }
                        }else if(rangeType.equals(CouponRangeType.CATAGORY.name())){
                            //  属于三级分类
                            if (skuInfo.getCategory3Id().longValue()==rangeId.longValue()){
                                skuIdList.add(skuId);
                            }
                        }else {
                            //  此时只剩品牌
                            if (skuInfo.getTmId().longValue()==rangeId.longValue()){
                                skuIdList.add(skuId);
                            }
                        }
                    }
                }
                //  将对应的skuIdList 赋值给当前优惠券对象
                couponInfo.setSkuIdList(skuIdList);
            }else {
                //  属于普通优惠券！
                if (rangeType.equals(CouponRangeType.SPU.name())){
                    //  赋值skuIdList
                    //  rangToSkuIdMap Map 集合数据 key = "range:1:"+ rangeId  value = skuIdList;
                    //  根据spuId 获取对应的skuIdList
                    couponInfo.setSkuIdList(rangToSkuIdMap.get("range:1:"+ rangeId));
                }else if (rangeType.equals(CouponRangeType.CATAGORY.name())){
                    //  根据category3Id 获取skuIdList
                    couponInfo.setSkuIdList(rangToSkuIdMap.get("range:2:"+ rangeId));
                }else {
                    //  品牌Id
                    couponInfo.setSkuIdList(rangToSkuIdMap.get("range:3:"+ rangeId));
                }
            }
        }
        //  声明一个集合
        Map<Long, List<CouponInfo>> map = new HashMap<>();

        //  循环遍历所有优惠券：
        for (CouponInfo couponInfo : allCouponInfoList) {
            //  获取到skuIdList 集合
            List<Long> skuIdList = couponInfo.getSkuIdList();
            //  循环遍历
            for (Long skuId : skuIdList) {
                //  判断
                if (map.containsKey(skuId)){
                    //  获取到优惠券列表集合 一个skuId 可以对应多个优惠券！
                    List<CouponInfo> couponInfoList = map.get(skuId);
                    couponInfoList.add(couponInfo);
                }else {
                    //  这个集合不包含这个key！
                    List<CouponInfo> couponInfoList = new ArrayList<>();
                    //  添加到这个集合
                    couponInfoList.add(couponInfo);
                    map.put(skuId,couponInfoList);
                }
            }
        }
        //  返回数据
        return map;
    }

    @Override
    public List<CouponInfo> findTradeCouponInfo(List<OrderDetail> orderDetailList, Map<Long, ActivityRule> activityIdToActivityRuleMap, Long userId) {
        //  数据初始化准备
        //  存储的是skuId  skuInfo
        Map<Long,SkuInfo> skuIdToSkuInfoMap = new HashMap<>();
        //  存储的是skuId  orderDetail
        Map<Long,OrderDetail> skuIdToOrderDetailMap = new HashMap<>();
        //  声明一个集合来存储skuInfo
        List<SkuInfo> skuInfoList = new ArrayList<>();
        //  定义一个集合 key = "range:1:" + skuInfo.getSpuId();
        Map<String,List<Long>> rangToSkuIdMap = new HashMap<>();

        for (OrderDetail orderDetail : orderDetailList) {
            //  需要通过远程调用获取
            SkuInfo skuInfo = productFeignClient.getSkuInfo(orderDetail.getSkuId());
            //  将skuInfo 添加到这个集合
            skuInfoList.add(skuInfo);
            skuIdToSkuInfoMap.put(orderDetail.getSkuId(),skuInfo);
            skuIdToOrderDetailMap.put(orderDetail.getSkuId(),orderDetail);
            //  初始化操作：
            this.setRuleData(skuInfo,rangToSkuIdMap);
        }

        //  根据skuInfoList 与 userId 来获取到所有的优惠券列表！
        List<CouponInfo> allCouponInfoList = couponInfoMapper.selectTradeCouponInfoList(skuInfoList,userId);
        //  循环遍历获取到每个优惠券对象！
        //  优惠券：普通优惠券：没有参与活动的  活动优惠券：当前优惠券参与了活动
        for (CouponInfo couponInfo : allCouponInfoList) {
            //  获取到rangeId
            Long rangeId = couponInfo.getRangeId();
            //  获取到优惠券的使用类型
            String rangeType = couponInfo.getRangeType();
            //  判断是活动，还是非活动
            if (couponInfo.getActivityId()!=null && couponInfo.getActivityId().longValue()!=0){
                //  活动优惠券
                Iterator<Map.Entry<Long, ActivityRule>> iterator = activityIdToActivityRuleMap.entrySet().iterator();
                while (iterator.hasNext()){
                    //  获取到集合中的数据
                    Map.Entry<Long, ActivityRule> entry = iterator.next();
                    Long activityId = entry.getKey();
                    ActivityRule activityRule = entry.getValue();
                    //  判断 如果activityIdToActivityRuleMap map 集合中的活动Id 与 优惠券的活动Id 一样。那么他们就是同一个活动！
                    if (couponInfo.getActivityId().longValue()==activityId.longValue()){
                        //  同一个活动下有哪些skuId
                        List<Long> activitySkuIdList = activityRule.getSkuIdList();

                        //  声明一个集合来存储skuIdList
                        List<Long> skuIdList = new ArrayList<>();

                        //  循环遍历
                        for (Long skuId : activitySkuIdList) {
                            //  根据这个skuId 获取到skuInfo
                            SkuInfo skuInfo = skuIdToSkuInfoMap.get(skuId);
                            //  skuInfo 中 tmId spuId category3Id ; 这三个Id 对应是优惠券的使用范围！
                            if (rangeType.equals(CouponRangeType.SPU.name())){
                                if (rangeId.longValue() == skuInfo.getSpuId().longValue()){
                                    //  将skuId 添加到一个集合中
                                    skuIdList.add(skuId);
                                }
                            }else if (rangeType.equals(CouponRangeType.CATAGORY.name())){
                                if (rangeId.longValue() == skuInfo.getCategory3Id().longValue()){
                                    //  将skuId 添加到一个集合中
                                    skuIdList.add(skuId);
                                }
                            }else {
                                if (rangeId.longValue() == skuInfo.getTmId().longValue()){
                                    //  将skuId 添加到一个集合中
                                    skuIdList.add(skuId);
                                }
                            }
                        }
                        //  给优惠券对应的skuIdList 赋值
                        couponInfo.setSkuIdList(skuIdList);
                    }
                }
            }else {
                //  属于普通优惠券！
                if (rangeType.equals(CouponRangeType.SPU.name())){
                    //  赋值skuIdList
                    //  rangToSkuIdMap Map 集合数据 key = "range:1:"+ rangeId  value = skuIdList;
                    //  根据spuId 获取对应的skuIdList
                    couponInfo.setSkuIdList(rangToSkuIdMap.get("range:1:"+ rangeId));
                }else if (rangeType.equals(CouponRangeType.CATAGORY.name())){
                    //  根据category3Id 获取skuIdList
                    couponInfo.setSkuIdList(rangToSkuIdMap.get("range:2:"+ rangeId));
                }else {
                    //  品牌Id
                    couponInfo.setSkuIdList(rangToSkuIdMap.get("range:3:"+ rangeId));
                }
            }
        }

        //  对同一张优惠券 ，下面的skuId 进行汇总！
        /**
         * rangeType(范围类型)  1:商品(spuid) 2:品类(三级分类id) 3:品牌
         * rangeId(范围id)
         * 同一张优惠券不能包含多个范围类型，同一张优惠券可以对应同一范围类型的多个范围id（即：同一张优惠券可以包含多个spuId）
         * 示例数据：
         * couponId   rangeType   rangeId
         * 1             1             20 小米 12,13,14
         * 1             1             30 华为 18
         * 2             1             20
         */
        //  以优惠券Id 进行分组
        Map<Long, List<CouponInfo>> couponInfoToListMap = allCouponInfoList.stream().collect(Collectors.groupingBy(couponInfo -> couponInfo.getId()));

        //  声明一个集合对象
        List<CouponInfo> resultCouponInfoList = new ArrayList<>();

        //  对这个集合循环遍历
        Iterator<Map.Entry<Long, List<CouponInfo>>> iterator = couponInfoToListMap.entrySet().iterator();
        while (iterator.hasNext()){
            //  获取到里面的数据
            Map.Entry<Long, List<CouponInfo>> entry = iterator.next();
            //  Long couponInfoId = entry.getKey();
            //  获取同一个Id 下的优惠券集合列表
            List<CouponInfo> couponInfoList = entry.getValue();

            //  声明一个skuIdList
            List<Long> skuIdList = new ArrayList<>();

            //  循环当前couponInfoList 集合
            for (CouponInfo couponInfo : couponInfoList) {
                //  对数据进行了汇总
                skuIdList.addAll(couponInfo.getSkuIdList());
            }

            //  将skuIdList 赋值给当前的优惠券
            CouponInfo couponInfo = couponInfoList.get(0);
            couponInfo.setSkuIdList(skuIdList); // 12,13,14,18
            //  把分组之后的couponInfo添加到这个集合resultCouponInfoList
            resultCouponInfoList.add(couponInfo);
        }
        //  我们需要选择一个最优的优惠券并且默认选中！
        //  优惠券类型 1.现金券 2. 折扣券 3. 满减券 4. 满件打折
        //  声明一个变量， 记录最优选项金额
        BigDecimal checkedAmount = new BigDecimal("0");

        //  声明一个变量  记录最优的优惠券
        CouponInfo checkedCouponInfo = null;

        //  循环遍历所有的优惠券
        for (CouponInfo couponInfo : resultCouponInfoList) {
            //  获取到优惠券下的订单明细 ，先获取到优惠券对应的skuIdList
            List<Long> skuIdList = couponInfo.getSkuIdList();
            //  声明一个变量记录总金额
            BigDecimal totalAmount = new BigDecimal("0");
            //  声明一个变量记录 订单明细的总件数
            int totalNum = 0;
            //  循环遍历skuIdList
            for (Long skuId : skuIdList) { // 12,13,14,15 ....
                //  通过skuId 获取到OrderDetail；
                OrderDetail orderDetail = skuIdToOrderDetailMap.get(skuId);
                //  获取到订单明细金额
                BigDecimal skuAmount = orderDetail.getOrderPrice().multiply(new BigDecimal(orderDetail.getSkuNum()));
                //  将所有的订单明细的金额进行汇总
                totalAmount = totalAmount.add(skuAmount);
                //  总件数
                totalNum+= orderDetail.getSkuNum();
            }
            //  优惠券： reduceAmount 优惠后减少的金额  isChecked 是否是最优选项 isSelect 是否可选
            //  声明一个变量， 记录优惠券的减少金额
            BigDecimal reduceAmount = new BigDecimal("0");
            //  判断优惠券的类型
            //  属于现金券
            if (couponInfo.getCouponType().equals(CouponType.CASH.name())){
                //  知道优惠券的金额是多少?
                reduceAmount = couponInfo.getBenefitAmount();
                //  标记可以选择 0 表示不可以选 1 表示可以选择
                couponInfo.setIsSelect(1);
            }else if (couponInfo.getCouponType().equals(CouponType.DISCOUNT.name())){ // 折扣券
                // 计算折扣的金额
                BigDecimal skuDiscountTotalAmount = totalAmount.multiply(couponInfo.getBenefitDiscount().divide(new BigDecimal("10")));
                //  计算优惠券的金额
                reduceAmount = totalAmount.subtract(skuDiscountTotalAmount);
                //  标记可以选择 0 表示不可以选 1 表示可以选择
                couponInfo.setIsSelect(1);
            }else if (couponInfo.getCouponType().equals(CouponType.FULL_REDUCTION.name())){ // 满减
                //  判断
                if (totalAmount.compareTo(couponInfo.getConditionAmount())>-1){
                    //  计算优惠券的金额
                    reduceAmount = couponInfo.getBenefitAmount();
                    //  标记可以选择 0 表示不可以选 1 表示可以选择
                    couponInfo.setIsSelect(1);
                }
            }else {
                //  满量打折
                if (totalNum>=couponInfo.getConditionNum().intValue()){
                    //  计算打折金额
                    BigDecimal skuNumDiscountTotalAmount = totalAmount.multiply(couponInfo.getBenefitDiscount().divide(new BigDecimal("10")));
                    //  计算优惠券的金额
                    reduceAmount = totalAmount.subtract(skuNumDiscountTotalAmount);
                    //  标记可以选择 0 表示不可以选 1 表示可以选择
                    couponInfo.setIsSelect(1);
                }
            }
            //  将最优的优惠价格做一个 优化处理！ 5 10 15 最终使用哪个？
            if (reduceAmount.compareTo(checkedAmount)>0){
                checkedAmount = reduceAmount;
                //  记录上当前这个优惠券是谁！
                checkedCouponInfo = couponInfo;
            }
            //  优惠后的减少金额
            couponInfo.setReduceAmount(reduceAmount);
        }

        //  判断找到最优的哪个优惠券并且做选中！
        if (checkedCouponInfo!=null){
            for (CouponInfo couponInfo : resultCouponInfoList) {
                if (couponInfo.getId().intValue() == checkedCouponInfo.getId().intValue()){
                    //  默认选中：
                    couponInfo.setIsChecked(1);
                }
            }
        }
        //  返回数据！
        return resultCouponInfoList;
    }

    @Override
    public void updateCouponInfoUseStatus(Long couponId, Long userId, Long orderId) {
        //  创建一个对象
        CouponUse couponUse = new CouponUse();
        couponUse.setOrderId(orderId);
        couponUse.setUsingTime(new Date());
        couponUse.setCouponStatus(CouponStatus.USED.name());

        //  设置更新条件
        QueryWrapper<CouponUse> couponUseQueryWrapper = new QueryWrapper<>();
        couponUseQueryWrapper.eq("coupon_id",couponId);
        couponUseQueryWrapper.eq("user_id",userId);
        //  更新数据
        couponUseMapper.update(couponUse,couponUseQueryWrapper);

    }

    //  设置优惠券对应的存储规则！
    private void setRuleData(SkuInfo skuInfo, Map<String, List<Long>> rangToSkuIdMap) {
        //  目的：rangToSkuIdMap 赋值操作 key = key1 key2 key3  value = skuIdList
        //  针对SPU;
        String key1 = "range:1:"+skuInfo.getSpuId();
        if (rangToSkuIdMap.containsKey(key1)){
            //  获取到对应的数据
            List<Long> skuIdList = rangToSkuIdMap.get(key1);
            //  将最新的skuId 添加到这个集合
            skuIdList.add(skuInfo.getId());
        }else {
            //  不包含这个key
            List<Long> skuIdList = new ArrayList<>();
            //  将最新的skuId 添加到这个集合
            skuIdList.add(skuInfo.getId());
            //  将数据放入rangToSkuIdMap 中！
            rangToSkuIdMap.put(key1,skuIdList);
        }

        //  针对分类Id
        String key2 = "range:2:"+skuInfo.getCategory3Id();
        if (rangToSkuIdMap.containsKey(key2)){
            //  获取到对应的数据
            List<Long> skuIdList = rangToSkuIdMap.get(key2);
            //  将最新的skuId 添加到这个集合
            skuIdList.add(skuInfo.getId());
        }else {
            //  不包含这个key
            List<Long> skuIdList = new ArrayList<>();
            //  将最新的skuId 添加到这个集合
            skuIdList.add(skuInfo.getId());
            //  将数据放入rangToSkuIdMap 中！
            rangToSkuIdMap.put(key2,skuIdList);
        }

        //  针对品牌
        String key3 = "range:3:"+skuInfo.getTmId();
        if (rangToSkuIdMap.containsKey(key3)){
            //  获取到对应的数据
            List<Long> skuIdList = rangToSkuIdMap.get(key3);
            //  将最新的skuId 添加到这个集合
            skuIdList.add(skuInfo.getId());
        }else {
            //  不包含这个key
            List<Long> skuIdList = new ArrayList<>();
            //  将最新的skuId 添加到这个集合
            skuIdList.add(skuInfo.getId());
            //  将数据放入rangToSkuIdMap 中！
            rangToSkuIdMap.put(key3,skuIdList);
        }
    }

}
